Spike Computational cost

SMART SAMPLES

First, imagine you want to sample the data to try different models faster. You could use the functions sample_n, but you would inccur the risk of having a undistributed sample (such as all observations in building 0)

Load data

pacman::p_load(readr, dplyr, caret, plotly, htmltools)


train <- read_csv("trainingData.csv", na = c("N/A"))

Sample data

sample <- train %>% group_by(FLOOR, BUILDINGID) %>% sample_n(10)

check frequency floor

table(sample$FLOOR)

## 
##  0  1  2  3  4 
## 30 30 30 30 10

check frequency building

table(sample$BUILDINGID)

## 
##  0  1  2 
## 40 40 50

plot sample - Building 0, Building 1, Building 2

sample$BUILDINGID <- as.character(sample$BUILDINGID)

    
a <- htmltools::tagList()    
for(i in unique(sample$BUILDINGID)){
a[[i]] <- sample %>% dplyr:: filter(BUILDINGID == i) %>% plot_ly(type = "scatter3d",
        x = ~ LATITUDE,
        y = ~ LONGITUDE,
        z = ~ FLOOR,
        mode = 'markers')


}    
    
a[[1]] # Building 0

a[[2]] # Building 1

a[[3]] # Building 2

SPECIFIC PACKAGES

# Load package
library(randomForest)

# Saving the waps in a vector
WAPs<-grep("WAP", names(train), value=T)

# Get the best mtry
bestmtry_rf<-tuneRF(sample[WAPs], sample$LONGITUDE, ntreeTry=100,stepFactor=2,improve=0.05,trace=TRUE, plot=T) 

# Train a random forest using that mtry
system.time(rf_reg<-randomForest(y=sample$LONGITUDE,x=sample[WAPs],importance=T,method="rf", ntree=100, mtry=22))

# Train a random forest using caret package
system.time(rf_reg_caret<-train(y=sample$LONGITUDE, x=sample[WAPs], data = sample, method="rf", ntree=100,tuneGrid=expand.grid(.mtry=22)))

# Load the package
library(caret)

# Saving the waps in a vector
WAPs<-grep("WAP", names(sample), value=T)

# calculate the pre-process parameters from the dataset
preprocessParams <- preProcess(sample[WAPs], method=c("center", "scale"))

# transform the waps using the parameters
stand_waps <- predict(preprocessParams, sample[WAPs])

# complete dataset
stand_dataset<-cbind(stand_waps, BUILDINGID=sample$BUILDINGID,LONGITUDE=sample$LONGITUDE)

# Train two classification knn (with knn3 and train)
system.time(knn_clasif <- knn3(BUILDINGID ~ as.matrix(stand_dataset[WAPs]), data = stand_dataset))

system.time(knn_clasif_caret<-train(y=stand_dataset$BUILDINGID, x=stand_dataset[WAPs], data = stand_dataset, method="knn"))

# Train two regression knn (with knnreg and caret)
system.time(knn_reg<-knnreg(LONGITUDE ~ as.matrix(stand_dataset[WAPs]), data = stand_dataset))

system.time(knn_reg_caret<-train(y=stand_dataset$LONGITUDE, x=stand_dataset[WAPs], data = stand_dataset, method="knn"))

# Load the packages
library(e1071)
library(caret)

# Saving the waps in a vector
WAPs<-grep("WAP", names(sample), value=T)

# Train two classification svm (with svm and train)
system.time(svm_clasif <- svm(y = stand_dataset$BUILDINGID, x=stand_dataset[WAPs]))

system.time(svm_clasif_caret<-train(y=stand_dataset$BUILDINGID, x=stand_dataset[WAPs], data = stand_dataset, method="svmLinear"))

# Train two regression svm (with svm and train)
system.time(svm_reg <- svm(y = stand_dataset$LONGITUDE, x=stand_dataset[WAPs]))

system.time(svm_reg_caret<-train(y=stand_dataset$LONGITUDE, x=as.matrix(stand_dataset[WAPs], data = stand_dataset, method="svmLinear")))

PARALLEL PROCESSING

A computer usually has multiple cores. Tipically, R is going to use only one of them, but we can increase this number, allowing us to execute more computations at the same time.

• Install the doParallel package
• Check how many cores you have with the function detectCores().
• Save the number of cores that you would like to execute with the function makeCluster(). A good practice is to leave one for other tasks.
• Register the cluster with the function registerDoParallel()

• Install the doMC package
• Check how many cores you have with the function getDoParWorkers()
• Save the number of cores that you would like to execute with the function makeCluster(). A good practice is to leave one for other tasks.
• Register the cluster with the function registerDoMC()

Now you can apply parallel processing! For example, you can use it in the cross validation or in the RF with the parameter “allowParallel = TRUE”.

Challenge: Train the same sample with parallel processing

# Load the library
library(doParallel)

# Check number of cores
detectCores()

# Save the number of cores I'm going to use
cluster <- makeCluster(detectCores() - 1)

# Register the cluster
registerDoParallel(cluster)

# Apply it on the cross validation
fitControl <- trainControl(method = "repeatedcv", number = 10, repeats = 3, allowParallel = TRUE)

SAVING AND LOADING MODELS

• For saving a model you can mainly use two functions: save(____.rda) or saveRDS(____.rds)
• For loading a model you will need to use load(____.rda) or readRDS(____.rds)

Your turn! Try to save and load some models.

# Save a model
saveRDS(RF_Model, file="RF_Model.rds")

# Load a model
final_model<-readRD("RF_Model.rds")